package mx.itesm.rmroman.proyectojuegomavi;

import android.content.res.AssetManager;
import android.util.Log;

import org.andengine.engine.Engine;
import org.andengine.engine.camera.Camera;
import org.andengine.opengl.texture.ITexture;
import org.andengine.opengl.texture.TextureManager;
import org.andengine.opengl.texture.TextureOptions;
import org.andengine.opengl.texture.atlas.bitmap.BitmapTextureAtlas;
import org.andengine.opengl.texture.atlas.bitmap.BitmapTextureAtlasTextureRegionFactory;
import org.andengine.opengl.texture.atlas.bitmap.BuildableBitmapTextureAtlas;
import org.andengine.opengl.texture.atlas.bitmap.source.IBitmapTextureAtlasSource;
import org.andengine.opengl.texture.atlas.buildable.builder.BlackPawnTextureAtlasBuilder;
import org.andengine.opengl.texture.atlas.buildable.builder.ITextureAtlasBuilder;
import org.andengine.opengl.texture.bitmap.AssetBitmapTexture;
import org.andengine.opengl.texture.region.ITextureRegion;
import org.andengine.opengl.texture.region.ITiledTextureRegion;
import org.andengine.opengl.texture.region.TextureRegionFactory;
import org.andengine.opengl.texture.region.TiledTextureRegion;
import org.andengine.opengl.vbo.VertexBufferObjectManager;

import java.io.IOException;

/**
 * Carga/Descarga los recurso del juego. Imágenes, Audios
 */
public class AdministradorRecursos
{
    // Instancia única de la clase
    private static final AdministradorRecursos INSTANCE =
            new AdministradorRecursos();

    public Engine engine;
    public ControlJuego actividadJuego;
    public Camera camara;
    public VertexBufferObjectManager vbom;

    // ** TEXTURAS **
    // Escena Splash (imagen estática)
    private ITexture texturaSplash;
    public ITextureRegion regionSplash;

    // * Escena Menú *
    // Imagen de fondo del menú
    private ITexture texturaFondoMenu;
    public ITextureRegion regionFondoMenu;
    // Botón jugar del menú (con dos estados, normal y presionado)
    public ITiledTextureRegion regionBtn2Jugar;
    private BuildableBitmapTextureAtlas btaBtn2Jugar;
    // Botón jugar del menú (para el menu de tipo MenuScene)
    private ITexture texturaBotonJugar;
    public ITextureRegion regionBotonJugar;
    // Botón acerca de del menú (para el menu de tipo MenuScene)
    private ITexture texturaBotonAcercaDe;
    public ITextureRegion regionBotonAcercaDe;
    // Botón jugar Dos
    private ITexture texturaBotonJugarDos;
    public ITextureRegion regionBotonJugarDos;
    // Botón para la escena con física
    private ITexture texturaBotonFisica;
    public ITextureRegion regionBotonFisica;

    // * Escena Acerca de *
    private ITexture texturaFondoAcercaDe;
    public ITextureRegion regionFondoAcercaDe;
    // Botón de regreso
    private BitmapTextureAtlas texturaBtnRegresar;
    public ITextureRegion regionBtnRegresar;
    // Burbuja para el sistema de partículas
    private BitmapTextureAtlas texturaBurbuja;
    public ITextureRegion regionBurbuja;
    private BitmapTextureAtlas texturaHumo;
    public ITextureRegion regionHumo;


    // * Escena JUEGO *
    // Fondo
    private ITexture texturaFondoJuego;
    public ITextureRegion regionFondoJuego;
    // 'Personaje', 'enemigo', 'item'
    private ITexture texturaMosca;
    public ITextureRegion regionMosca;
    // Matamoscas
    private ITexture texturaMatamoscas;
    public ITextureRegion regionMatamoscas;
    // Joystick virtual (fondo fijo y el botón movible)
    private ITexture texturaFondoControl;
    public ITextureRegion regionFondoControl;
    private ITexture texturaBotonControl;
    public ITextureRegion regionBotonControl;
    // Enemigo, mosca mala
    private ITexture texturaMoscaMala;
    public ITextureRegion regionMoscaMala;

    // * Escena JUEGO DOS *
    // *** Fondos para la animación en capas
    private ITexture texturaFondoLejos;
    public ITextureRegion regionFondoLejos;
    private ITexture texturaFondoMedio;
    public ITextureRegion regionFondoMedio;
    private ITexture texturaFondoCerca;
    public ITextureRegion regionFondoCerca;
    // Personaje animado sobre la pantalla
    private BuildableBitmapTextureAtlas texturaPerroAnimado;
    public TiledTextureRegion regionPerroAnimado;
    // ENEMIGO, una piedra
    private ITexture texturaRoca;
    public ITextureRegion regionRoca;


    // * Escena de un mundo con FÍSICA


    // Método accesor de la instancia
    public static AdministradorRecursos getInstance() {
        return INSTANCE;
    }

    // Asigna valores iniciales del administrador
    public static void inicializarAdministrador(Engine engine,
                                                ControlJuego control, Camera camara, VertexBufferObjectManager vbom) {

        getInstance().engine = engine;
        getInstance().actividadJuego = control;
        getInstance().camara = camara;
        getInstance().vbom = vbom;
    }

    //*** Recursos de la pantalla de Splash
    public void cargarRecursosSplash() {
        try {
            // Carga la imagen de fondo de la pantalla Splash
            texturaSplash = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "logoTec.png");
            regionSplash = TextureRegionFactory.extractFromTexture(texturaSplash);
            texturaSplash.load();
        } catch (IOException e) {
            Log.d("cargarRecursosSplash", "No se puede cargar el fondo");
        }
    }

    public void liberarRecursosSplash() {
        texturaSplash.unload();
        regionSplash = null;
    }

    //*** Recursos de la pantalla de Menú
    public void cargarRecursosMenu() {
        try {
            // Carga la imagen de fondo de la pantalla del Menú
            texturaFondoMenu = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "menu/menuFondo.png");
            regionFondoMenu = TextureRegionFactory.extractFromTexture(texturaFondoMenu);
            texturaFondoMenu.load();
            // Carga la imagen para el botón jugar (2 estados)
            btaBtn2Jugar = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),
                    256, 128);
            regionBtn2Jugar = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(btaBtn2Jugar, actividadJuego.getAssets(),
                    "btnJugarDos.png", 2, 1);
            try {
                btaBtn2Jugar.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0, 0, 0));

            } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
                Log.d("cargarRecursosMenu", "No se puede cargar la imagen del botón jugar");
            }
            btaBtn2Jugar.load();
            // Fin de carga imagen botón jugar
        } catch (IOException e) {
            Log.d("cargarRecursosMenu", "No se puede cargar el fondo");
        }
        // Cargar las imágenes de los botones
        cargarBotonesMenu();
    }

    // Carga las imágenes de los botones del menú principal
    private void cargarBotonesMenu() {
        try {
            // Carga la imagen del botón acercaDe
            texturaBotonAcercaDe = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "menu/btnAbout.png");
            regionBotonAcercaDe = TextureRegionFactory.extractFromTexture(texturaBotonAcercaDe);
            texturaBotonAcercaDe.load();

            // Carga la imagen para el botón jugar
            texturaBotonJugar = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "menu/btnJugar.png");
            regionBotonJugar = TextureRegionFactory.extractFromTexture(texturaBotonJugar);
            texturaBotonJugar.load();

            // Carga la imagen para el botón jugar Dos
            texturaBotonJugarDos = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "menu/btnJugarDos.png");
            regionBotonJugarDos = TextureRegionFactory.extractFromTexture(texturaBotonJugarDos);
            texturaBotonJugarDos.load();

            // Carga la imagen para el botón de física
            texturaBotonFisica = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "fisica/btnFisica.png");
            regionBotonFisica = TextureRegionFactory.extractFromTexture(texturaBotonFisica);
            texturaBotonFisica.load();
        } catch (IOException e) {
            Log.d("cargarBotonesMenu", "No se pueden cargar las imágenes");
        }
    }

    public void liberarRecursosMenu() {
        // Fondo
        texturaFondoMenu.unload();
        regionFondoMenu = null;
        // botón jugar
        btaBtn2Jugar.unload();
        regionBtn2Jugar = null;
        // Botones del menú
        texturaBotonAcercaDe.unload();
        texturaBotonJugar.unload();
        texturaBotonJugarDos.unload();
        regionBotonAcercaDe=null;
        regionBotonJugar=null;
        regionBotonJugarDos=null;
    }

    //*** Recursos de la pantalla de Aerca De
    public void cargarRecursosAcercaDe() {
        try {
            // Carga la imagen de fondo de la pantalla Splash
            texturaFondoAcercaDe = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "acercade/agua.png");
            regionFondoAcercaDe = TextureRegionFactory.extractFromTexture(texturaFondoAcercaDe);
            texturaFondoAcercaDe.load();
            // Carga la imagen del botón regresar
            texturaBtnRegresar = new BitmapTextureAtlas(actividadJuego.getTextureManager(),
                    128, 128, TextureOptions.BILINEAR);
            regionBtnRegresar = BitmapTextureAtlasTextureRegionFactory.createFromAsset(texturaBtnRegresar,
                    actividadJuego, "acercade/regresar.png", 0, 0);
            texturaBtnRegresar.load();
            // Cargar la imagen de la burbuja
            texturaBurbuja = new BitmapTextureAtlas(actividadJuego.getTextureManager(),
                    64, 64, TextureOptions.BILINEAR);
            regionBurbuja = BitmapTextureAtlasTextureRegionFactory.createFromAsset(texturaBurbuja,
                    actividadJuego, "acercade/burbuja.png", 0, 0);
            texturaBurbuja.load();
            // Cargar la imagen de humo
            texturaHumo = new BitmapTextureAtlas(actividadJuego.getTextureManager(),
                    64, 64, TextureOptions.BILINEAR);
            regionHumo = BitmapTextureAtlasTextureRegionFactory.createFromAsset(texturaHumo,
                    actividadJuego, "acercade/humo.png", 0, 0);
            texturaHumo.load();
        } catch (IOException e) {
            Log.d("cargarRecursosAcercaDe", "No se pueden cargar las imágenes");
        }
    }

    public void liberarRecursosAcercaDe() {
        // Fondo
        texturaFondoAcercaDe.unload();
        regionFondoAcercaDe = null;
        // Btn regresar
        texturaBtnRegresar.unload();
        regionBtnRegresar = null;
        // Burbuja del sistema de partículas
        texturaBurbuja.unload();
        regionBurbuja = null;
        // Humo
        texturaHumo.unload();
        regionHumo = null;
    }

    //*** Recursos de la pantalla de JUEGO
    public void cargarRecursosJuego() {
        try {
            // Para no llamar al método muchas veces
            TextureManager admTexturas = actividadJuego.getTextureManager();
            AssetManager assets = actividadJuego.getAssets();
            // Carga la imagen de fondo de la pantalla Splash
            texturaFondoJuego = new AssetBitmapTexture(admTexturas,
                    assets, "juego/fondoJuego.jpg");
            regionFondoJuego = TextureRegionFactory.extractFromTexture(texturaFondoJuego);
            texturaFondoJuego.load();
            // Cargar la 'mosca'
            texturaMosca = new AssetBitmapTexture(admTexturas,
                    assets, "juego/mosca.png");
            regionMosca = TextureRegionFactory.extractFromTexture(texturaMosca);
            texturaMosca.load();
            // Cargar el 'matamoscas'
            texturaMatamoscas = new AssetBitmapTexture(admTexturas,
                    assets, "juego/matamoscas.png");
            regionMatamoscas = TextureRegionFactory.extractFromTexture(texturaMatamoscas);
            texturaMatamoscas.load();
            // Crear las imágenes de fondo y botón para el joystick virtual
            texturaFondoControl = new AssetBitmapTexture(admTexturas,
                    assets, "juego/BaseControl.png");
            regionFondoControl = TextureRegionFactory.extractFromTexture(texturaFondoControl);
            texturaFondoControl.load();
            texturaBotonControl = new AssetBitmapTexture(admTexturas,
                    assets, "juego/BotonControl.png");
            regionBotonControl = TextureRegionFactory.extractFromTexture(texturaBotonControl);
            texturaBotonControl.load();
            // Cargar la 'mosca mala'
            texturaMoscaMala = new AssetBitmapTexture(admTexturas,
                    assets, "juego/moscaMala.png");
            regionMoscaMala = TextureRegionFactory.extractFromTexture(texturaMoscaMala);
            texturaMoscaMala.load();

        } catch (IOException e) {
            Log.d("cargarRecursosJuego", "No se puede cargar el fondo");
        }
    }

    public void liberarRecursosJuego() {
        // fondo
        texturaFondoJuego.unload();
        regionFondoJuego = null;
        // mosca
        texturaMosca.unload();
        texturaMosca = null;
        // matamoscas
        texturaMatamoscas.unload();
        regionMatamoscas = null;
        // Joystick virtual
        texturaFondoControl.unload();
        regionFondoControl = null;
        texturaBotonControl.unload();
        regionBotonControl = null;
        // Mosca mala
        texturaMoscaMala.unload();
        texturaMoscaMala = null;
    }

    public void cargarRecursosJuegoDos() {
        try {
            // *** Fondos para la animación en capas
            texturaFondoLejos = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "juegoDos/mar.png");
            regionFondoLejos = TextureRegionFactory.extractFromTexture(texturaFondoLejos);
            texturaFondoLejos.load();
            texturaFondoMedio = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "juegoDos/montanas.png");
            regionFondoMedio = TextureRegionFactory.extractFromTexture(texturaFondoMedio);
            texturaFondoMedio.load();
            texturaFondoCerca = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "juegoDos/pasto.png");
            regionFondoCerca = TextureRegionFactory.extractFromTexture(texturaFondoCerca);
            texturaFondoCerca.load();
            // Enemigo (Roca)
            texturaRoca = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "juegoDos/piedra.png");
            regionRoca = TextureRegionFactory.extractFromTexture(texturaRoca);
            texturaRoca.load();

        } catch (IOException e) {
            Log.d("cargarRecursosAcercaDe", "No se pueden cargar las imágenes");
        }

        // Carga las imágenes para el perro Animado
        texturaPerroAnimado = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),912,862);
        regionPerroAnimado = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(
                texturaPerroAnimado,actividadJuego, "juegoDos/hero_walk.png",4,6);

        try {
            texturaPerroAnimado.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0,0,0));
        } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
            Log.d("onCreateResources","No se puede cargar la imagen para el Sprite del perro Animado");
        }
        texturaPerroAnimado.load();
    }

    public void liberarRecursosJuegoDos() {
        // Capas del fondo
        texturaFondoLejos.unload();
        regionFondoLejos = null;
        texturaFondoMedio.unload();
        regionFondoMedio = null;
        texturaFondoCerca.unload();
        regionFondoCerca = null;
        // Perro animado
        texturaPerroAnimado.unload();
        regionPerroAnimado = null;
    }

    public void cargarRecursosFisica() {

    }

    public void liberarRecursosFisica() {

    }
}
